<?php
/**
 * 基于tp5的validate类的改造
 *
 * 使用方式
 *     http://www.kancloud.cn/manual/thinkphp5/129356
 *
 * 验证规则
 *     string  [字符串]
 *     present [必存在且可为空]
 *     json    [json串]
 *
 * 新增方法 getValues() [check成功,用来获取有效值数组]
 *
 * 注意事项
 *     入参避免tp的I方法接收
 *
 * @author guoquan <1257669560@qq.com>
 */
class Validate
{
	// 实例
	protected static $instance;

	// 自定义的验证类型
	protected static $type = [];

	// 验证类型别名
	protected $alias = [
		'>' => 'gt', '>=' => 'egt', '<' => 'lt', '<=' => 'elt', '=' => 'eq', 'same' => 'eq',
	];

	// 当前验证的规则
	protected $rule = [];

	// 验证提示信息
	protected $message = [];

	// 验证规则默认提示信息
	protected static $typeMsg = [
		'require'     => ':attribute不能为空',
		'present'     => ':attribute必须存在',
		'number'      => ':attribute必须是数字',
		'float'       => ':attribute必须是浮点数',
		'boolean'     => ':attribute必须是布尔值',
		'json'        => ':attribute必须是json',
		'email'       => ':attribute格式不符',
		'array'       => ':attribute必须是数组',
		'string'      => ':attribute必须是字符串',
		'accepted'    => ':attribute必须是yes、on或者1',
		'date'        => ':attribute格式不符合',
		'file'        => ':attribute不是有效的上传文件',
		'image'       => ':attribute不是有效的图像文件',
		'alpha'       => ':attribute只能是字母',
		'alphaNum'    => ':attribute只能是字母和数字',
		'alphaDash'   => ':attribute只能是字母、数字和下划线_及破折号-',
		'activeUrl'   => ':attribute不是有效的域名或者IP',
		'chs'         => ':attribute只能是汉字',
		'chsAlpha'    => ':attribute只能是汉字、字母',
		'chsAlphaNum' => ':attribute只能是汉字、字母和数字',
		'chsDash'     => ':attribute只能是汉字、字母、数字和下划线_及破折号-',
		'url'         => ':attribute不是有效的URL地址',
		'ip'          => ':attribute不是有效的IP地址',
		'dateFormat'  => ':attribute必须使用日期格式 :rule',
		'in'          => ':attribute必须在 :rule 范围内',
		'notIn'       => ':attribute不能在 :rule 范围内',
		'between'     => ':attribute只能在 :1 - :2 之间',
		'notBetween'  => ':attribute不能在 :1 - :2 之间',
		'length'      => ':attribute长度不符合要求 :rule',
		'max'         => ':attribute长度不能超过 :rule',
		'min'         => ':attribute长度不能小于 :rule',
		'after'       => ':attribute日期不能小于 :rule',
		'before'      => ':attribute日期不能超过 :rule',
		'expire'      => '不在有效期内 :rule',
		'allowIp'     => '不允许的IP访问',
		'denyIp'      => '禁止的IP访问',
		'confirm'     => ':attribute和字段 :rule 不一致',
		'different'   => ':attribute和字段 :rule 不能相同',
		'egt'         => ':attribute必须大于等于 :rule',
		'gt'          => ':attribute必须大于 :rule',
		'elt'         => ':attribute必须小于等于 :rule',
		'lt'          => ':attribute必须小于 :rule',
		'eq'          => ':attribute必须等于 :rule',
		'unique'      => ':attribute已存在',
		'regex'       => ':attribute不符合指定规则',
		'method'      => '无效的请求类型',
		'token'       => '令牌数据无效',
		'fileSize'    => '上传文件大小不符',
		'fileExt'     => '上传文件后缀不符',
		'fileMime'    => '上传文件类型不符',

	];

	// 当前验证场景
	protected $currentScene = null;

	// 正则表达式 regex = ['zip'=>'\d{6}',...]
	protected $regex = [];

	// 验证场景 scene = ['edit'=>'name1,name2,...']
	protected $scene = [];

	// 验证失败错误信息
	protected $error = [];

	// 批量验证
	protected $batch = false;

	/**
	 * 架构函数
	 * @access public
	 * @param array $rules 验证规则
	 * @param array $message 验证提示信息
	 */
	public function __construct(array $rules = [], $message = [])
	{
		$this->rule    = array_merge($this->rule, $rules);
		$this->message = array_merge($this->message, $message);
	}

	/**
	 * 实例化验证
	 * @access public
	 * @param array     $rules 验证规则
	 * @param array     $message 验证提示信息
	 * @return Validate
	 */
	public static function make($rules = [], $message = [])
	{
		if (is_null(self::$instance)) {
			self::$instance = new self($rules, $message);
		}
		return self::$instance;
	}

	/**
	 * 添加字段验证规则
	 * @access protected
	 * @param string|array  $name  字段名称或者规则数组
	 * @param mixed         $rule  验证规则
	 * @return Validate
	 */
	public function rule($name, $rule = '')
	{
		if (is_array($name)) {
			$this->rule = array_merge($this->rule, $name);
		} else {
			$this->rule[$name] = $rule;
		}
		return $this;
	}

	/**
	 * 注册验证（类型）规则
	 * @access public
	 * @param string    $type  验证规则类型
	 * @param mixed     $callback callback方法(或闭包)
	 * @return void
	 */
	public static function extend($type, $callback = null)
	{
		if (is_array($type)) {
			self::$type = array_merge(self::$type, $type);
		} else {
			self::$type[$type] = $callback;
		}
	}

	/**
	 * 获取验证规则的默认提示信息
	 * @access protected
	 * @param string|array  $type  验证规则类型名称或者数组
	 * @param string        $msg  验证提示信息
	 * @return void
	 */
	public static function setTypeMsg($type, $msg = null)
	{
		if (is_array($type)) {
			self::$typeMsg = array_merge(self::$typeMsg, $type);
		} else {
			self::$typeMsg[$type] = $msg;
		}
	}

	/**
	 * 设置提示信息
	 * @access public
	 * @param string|array  $name  字段名称
	 * @param string        $message 提示信息
	 * @return Validate
	 */
	public function message($name, $message = '')
	{
		if (is_array($name)) {
			$this->message = array_merge($this->message, $name);
		} else {
			$this->message[$name] = $message;
		}
		return $this;
	}

	/**
	 * 设置验证场景
	 * @access public
	 * @param string|array  $name  场景名或者场景设置数组
	 * @param mixed         $fields 要验证的字段
	 * @return Validate
	 */
	public function scene($name, $fields = null)
	{
		if (is_array($name)) {
			$this->scene = array_merge($this->scene, $name);
		}if (is_null($fields)) {
		// 设置当前场景
		$this->currentScene = $name;
	} else {
		// 设置验证场景
		$this->scene[$name] = $fields;
	}
		return $this;
	}

	/**
	 * 设置批量验证
	 * @access public
	 * @param bool $batch  是否批量验证
	 * @return Validate
	 */
	public function batch($batch = true)
	{
		$this->batch = $batch;
		return $this;
	}

	/**
	 * get the valid data where check success
	 *
	 * @author guoquan <1257669560@qq.com>
	 *
	 * @return array
	 */
	public function getValues()
	{
		$values = [];
		foreach ($this->rule as $field => $rule) {
			$value = $this->getDataValue($this->data, $field);
			if (is_string($rule)) {
				$rule = explode('|', $rule);
			}
			if ($this->isKeyExists($field, $this->data)) {
				//non-present ignore the value
				if ('' === $value && !in_array('present', $rule)) {
					continue;
				}
				if (strpos($field, '.')) {
					list($name1, $name2)    = explode('.', $field);
					$values[$name1][$name2] = $value;
				} else {
					$values[$field] =  $value;
				}
			}
		}
		return $values;
	}

	/**
	 * detect the existence of key
	 *
	 * @author guoquan <1257669560@qq.com>
	 * @param  string $key  支持key1.key2形式
	 * @param  array  $data
	 *
	 * @retrun bool
	 */
	protected function isKeyExists($key, array $data)
	{
		if (strpos($key, '.')) {
			list($name1, $name2) = explode('.', $key);
			if (!array_key_exists($name1, $data) ||
				(is_array($data[$name1]) && !array_key_exists($name2, $data[$name1]))
			) {
				return false;
			}
		} else {
			if (!array_key_exists($key, $data)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 数据自动验证
	 * @access public
	 * @param array     $data  数据
	 * @param mixed     $rules  验证规则
	 * @param string    $scene 验证场景
	 * @return bool
	 */
	public function check($data, $rules = [], $scene = '')
	{
		$this->data = $data;

		$this->error = [];

		if (empty($rules)) {
			// 读取验证规则
			$rules = $this->rule;
		}

		// 分析验证规则
		$scene = $this->getScene($scene);
		if (is_array($scene)) {
			// 处理场景验证字段
			$change = [];
			$array  = [];
			foreach ($scene as $k => $val) {
				if (is_numeric($k)) {
					$array[] = $val;
				} else {
					$array[]    = $k;
					$change[$k] = $val;
				}
			}
		}

		foreach ($rules as $key => $item) {
			// field => rule1|rule2... field=>['rule1','rule2',...]
			if (is_numeric($key)) {
				// [field,rule1|rule2,msg1|msg2]
				$key  = $item[0];
				$rule = $item[1];
				if (isset($item[2])) {
					$msg = is_string($item[2]) ? explode('|', $item[2]) : $item[2];
				} else {
					$msg = [];
				}
			} else {
				$rule = $item;
				$msg  = [];
			}
			if (strpos($key, '|')) {
				// 字段|描述 用于指定属性名称
				list($key, $title) = explode('|', $key);
			} else {
				$title = $key;
			}

			// 场景检测
			if (!empty($scene)) {
				if ($scene instanceof \Closure && !call_user_func_array($scene, [$key, $data])) {
					continue;
				} elseif (is_array($scene)) {
					if (!in_array($key, $array)) {
						continue;
					} elseif (isset($change[$key])) {
						// 重载某个验证规则
						$rule = $change[$key];
					}
				}
			}

			// 获取数据 支持二维数组
			$value = $this->getDataValue($data, $key);

			// 字段验证
			$result = $this->checkItem($key, $value, $rule, $data, $title, $msg);

			if (true !== $result) {
				// 没有返回true 则表示验证失败
				if (!empty($this->batch)) {
					// 批量验证
					if (is_array($result)) {
						$this->error = array_merge($this->error, $result);
					} else {
						$this->error[$key] = $result;
					}
				} else {
					$this->error = $result;
					return false;
				}
			}
		}
		return !empty($this->error) ? false : true;
	}

	/**
	 * 验证单个字段规则
	 * @access protected
	 * @param string    $field  字段名
	 * @param mixed     $value  字段值
	 * @param mixed     $rules  验证规则
	 * @param array     $data  数据
	 * @param string    $title  字段描述
	 * @param array     $msg  提示信息
	 * @return mixed
	 */
	protected function checkItem($field, $value, $rules, $data, $title = '', $msg = [])
	{
		if ($rules instanceof \Closure) {
			// 匿名函数验证 支持传入当前字段和所有字段两个数据
			$result = call_user_func_array($rules, [$value, $data]);
		} else {
			// 支持多规则验证 require|in:a,b,c|... 或者 ['require','in'=>'a,b,c',...]
			if (is_string($rules)) {
				$rules = explode('|', $rules);
			}
			$i = 0;
			foreach ($rules as $key => $rule) {
				if ($rule instanceof \Closure) {
					$result = call_user_func_array($rule, [$value, $data]);
				} else {
					// 判断验证类型
					if (is_numeric($key) && strpos($rule, ':')) {
						list($type, $rule) = explode(':', $rule, 2);
						if (isset($this->alias[$type])) {
							// 判断别名
							$type = $this->alias[$type];
						}
						$info = $type;
					} elseif (is_numeric($key)) {
						$type = 'is';
						$info = $rule;
					} else {
						$info = $type = $key;
					}

					// 如果不是require 有数据才会行验证
					if (0 === strpos($info, 'require') || 0 === strpos($info, 'present') || (!is_null($value) && '' !== $value)) {
						// 验证类型
						$callback = isset(self::$type[$type]) ? self::$type[$type] : [$this, $type];
						// 验证数据
						$result = call_user_func_array($callback, [$value, $rule, $data, $field]);
					} else {
						$result = true;
					}
				}

				if (false === $result) {
					// 验证失败 返回错误信息
					if (isset($msg[$i])) {
						$message = $msg[$i];
					} else {
						$message = $this->getRuleMsg($field, $title, $info, $rule);
					}
					return $message;
				} elseif (true !== $result) {
					// 返回自定义错误信息
					return $result;
				}
				$i++;
			}
		}
		return true !== $result ? $result : true;
	}

	/**
	 * 验证是否和某个字段的值一致
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @param array     $data  数据
	 * @return bool
	 */
	protected function confirm($value, $rule, $data)
	{
		return $this->getDataValue($data, $rule) == $value;
	}

	/**
	 * 验证是否和某个字段的值是否不同
	 * @access protected
	 * @param mixed $value 字段值
	 * @param mixed $rule  验证规则
	 * @param array $data  数据
	 * @return bool
	 */
	protected function different($value, $rule, $data)
	{
		return $this->getDataValue($data, $rule) != $value;
	}

	/**
	 * 验证是否大于等于某个值
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function egt($value, $rule)
	{
		return $value >= $rule;
	}

	/**
	 * 验证是否大于某个值
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function gt($value, $rule)
	{
		return $value > $rule;
	}

	/**
	 * 验证是否小于等于某个值
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function elt($value, $rule)
	{
		return $value <= $rule;
	}

	/**
	 * 验证是否小于某个值
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function lt($value, $rule)
	{
		return $value < $rule;
	}

	/**
	 * 验证是否等于某个值
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function eq($value, $rule)
	{
		return $value == $rule;
	}

	/**
	 * 验证字段值是否为有效格式
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param string    $rule  验证规则
	 * @return bool
	 */
	protected function is($value, $rule)
	{
		switch ($rule) {
			case 'require':
				// 必须
				$result = !empty($value) || '0' == $value;
				break;
			case 'present':
				$result = null !== $value;
				break;
			case 'json':
				// 是否是json
				if (!is_scalar($value) && ! method_exists($value, '__toString')) {
					$result = false;
				} else {
					json_decode($value);
					$result = json_last_error() === JSON_ERROR_NONE;
				}
				break;
			case 'accepted':
				// 接受
				$result = in_array($value, ['1', 'on', 'yes']);
				break;
			case 'date':
				// 是否是一个有效日期
				$result = false !== strtotime($value);
				break;
			case 'alpha':
				// 只允许字母
				$result = $this->regex($value, '/^[A-Za-z]+$/');
				break;
			case 'alphaNum':
				// 只允许字母和数字
				$result = $this->regex($value, '/^[A-Za-z0-9]+$/');
				break;
			case 'alphaDash':
				// 只允许字母、数字和下划线 破折号
				$result = $this->regex($value, '/^[A-Za-z0-9\-\_]+$/');
				break;
			case 'chs':
				// 只允许汉字
				$result = $this->regex($value, '/^[\x{4e00}-\x{9fa5}]+$/u');
				break;
			case 'chsAlpha':
				// 只允许汉字、字母
				$result = $this->regex($value, '/^[\x{4e00}-\x{9fa5}a-zA-Z]+$/u');
				break;
			case 'chsAlphaNum':
				// 只允许汉字、字母和数字
				$result = $this->regex($value, '/^[\x{4e00}-\x{9fa5}a-zA-Z0-9]+$/u');
				break;
			case 'chsDash':
				// 只允许汉字、字母、数字和下划线_及破折号-
				$result = $this->regex($value, '/^[\x{4e00}-\x{9fa5}a-zA-Z0-9\_\-]+$/u');
				break;
			case 'activeUrl':
				// 是否为有效的网址
				$result = checkdnsrr($value);
				break;
			case 'ip':
				// 是否为IP地址
				$result = $this->filter($value, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4 | FILTER_FLAG_IPV6);
				break;
			case 'url':
				// 是否为一个URL地址
				$result = $this->filter($value, FILTER_VALIDATE_URL);
				break;
			case 'float':
				// 是否为float
				$result = $this->filter($value, FILTER_VALIDATE_FLOAT);
				break;
			case 'number':
			case 'integer':
				// 是否为整形
				$result = $this->filter($value, FILTER_VALIDATE_INT);
				break;
			case 'email':
				// 是否为邮箱地址
				$result = $this->filter($value, FILTER_VALIDATE_EMAIL);
				break;
			case 'boolean':
				// 是否为布尔值
				//$result = $this->filter($value, FILTER_VALIDATE_BOOLEAN);
				$result = is_bool($value);
				break;
			case 'array':
				// 是否为数组
				$result = is_array($value);
				break;
			case 'string':
				$result = is_string($value);
				break;
			case 'file':
				$result = $value instanceof \think\File;
				break;
			case 'image':
				$result = $value instanceof \think\File && in_array($this->getImageType($value->getRealPath()), [1, 2, 3, 6]);
				break;
			default:
				if (isset(self::$type[$rule])) {
					// 注册的验证规则
					$result = call_user_func_array(self::$type[$rule], [$value]);
				} else {
					// 正则验证
					$result = $this->regex($value, $rule);
				}
		}
		return $result;
	}

	// 判断图像类型
	protected function getImageType($image)
	{
		if (function_exists('exif_imagetype')) {
			return exif_imagetype($image);
		} else {
			$info = getimagesize($image);
			return $info[2];
		}
	}

	/**
	 * 验证是否为合格的域名或者IP 支持A，MX，NS，SOA，PTR，CNAME，AAAA，A6， SRV，NAPTR，TXT 或者 ANY类型
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function activeUrl($value, $rule)
	{
		return checkdnsrr($value, $rule);
	}

	/**
	 * 验证是否有效IP
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则 ipv4 ipv6
	 * @return bool
	 */
	protected function ip($value, $rule)
	{
		if (!in_array($rule, ['ipv4', 'ipv6'])) {
			$rule = 'ipv4';
		}
		return $this->filter($value, FILTER_VALIDATE_IP, 'ipv6' == $rule ? FILTER_FLAG_IPV6 : FILTER_FLAG_IPV4);
	}

	/**
	 * 验证上传文件后缀
	 * @access protected
	 * @param mixed     $file  上传文件
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function fileExt($file, $rule)
	{
		if (!($file instanceof \think\File)) {
			return false;
		}
		if (is_string($rule)) {
			$rule = explode(',', $rule);
		}
		if (is_array($file)) {
			foreach ($file as $item) {
				if (!$item->checkExt($rule)) {
					return false;
				}
			}
			return true;
		} else {
			return $file->checkExt($rule);
		}
	}

	/**
	 * 验证上传文件类型
	 * @access protected
	 * @param mixed     $file  上传文件
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function fileMime($file, $rule)
	{
		if (!($file instanceof \think\File)) {
			return false;
		}
		if (is_string($rule)) {
			$rule = explode(',', $rule);
		}
		if (is_array($file)) {
			foreach ($file as $item) {
				if (!$item->checkMime($rule)) {
					return false;
				}
			}
			return true;
		} else {
			return $file->checkMime($rule);
		}
	}

	/**
	 * 验证上传文件大小
	 * @access protected
	 * @param mixed     $file  上传文件
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function fileSize($file, $rule)
	{
		if (!($file instanceof \think\File)) {
			return false;
		}
		if (is_array($file)) {
			foreach ($file as $item) {
				if (!$item->checkSize($rule)) {
					return false;
				}
			}
			return true;
		} else {
			return $file->checkSize($rule);
		}
	}

	/**
	 * 验证图片的宽高及类型
	 * @access protected
	 * @param mixed     $file  上传文件
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function image($file, $rule)
	{
		if (!($file instanceof \think\File)) {
			return false;
		}
		$rule                        = explode(',', $rule);
		list($width, $height, $type) = getimagesize($file->getRealPath());
		if (isset($rule[2])) {
			$imageType = strtolower($rule[2]);
			if ('jpeg' == $imageType) {
				$imageType = 'jpg';
			}
			if (image_type_to_extension($type, false) != $imageType) {
				return false;
			}
		}
		list($w, $h) = $rule;
		return $w == $width && $h == $height;
	}

	/**
	 * 验证请求类型
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function method($value, $rule)
	{
		$method = $_SERVER['REQUEST_METHOD'];
		return strtoupper($rule) == $method;
	}

	/**
	 * 验证时间和日期是否符合指定格式
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function dateFormat($value, $rule)
	{
		$info = date_parse_from_format($rule, $value);
		return 0 == $info['warning_count'] && 0 == $info['error_count'];
	}

	/**
	 * 验证是否唯一
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则 格式：数据表,字段名,排除ID,主键名
	 * @param array     $data  数据
	 * @param string    $field  验证字段名
	 * @return bool
	 */
	protected function unique($value, $rule, $data, $field)
	{
		if (is_string($rule)) {
			$rule = explode(',', $rule);
		}
		$db  = Db::name($rule[0]);
		$key = isset($rule[1]) ? $rule[1] : $field;

		if (strpos($key, '^')) {
			// 支持多个字段验证
			$fields = explode('^', $key);
			foreach ($fields as $key) {
				$map[$key] = $data[$key];
			}
		} elseif (strpos($key, '=')) {
			parse_str($key, $map);
		} else {
			$map[$key] = $data[$field];
		}

		$pk = strval(isset($rule[3]) ? $rule[3] : $db->getPk());
		if (isset($rule[2])) {
			$map[$pk] = ['neq', $rule[2]];
		} elseif (isset($data[$pk])) {
			$map[$pk] = ['neq', $data[$pk]];
		}

		if ($db->where($map)->field($pk)->find()) {
			return false;
		}
		return true;
	}

	/**
	 * 使用行为类验证
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @param array     $data  数据
	 * @return mixed
	 */
	protected function behavior($value, $rule, $data)
	{
		return Hook::exec($rule, '', $data);
	}

	/**
	 * 使用filter_var方式验证
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function filter($value, $rule)
	{
		if (is_string($rule) && strpos($rule, ',')) {
			list($rule, $param) = explode(',', $rule);
		} elseif (is_array($rule)) {
			$param = isset($rule[1]) ? $rule[1] : null;
		} else {
			$param = null;
		}
		return false !== filter_var($value, is_int($rule) ? $rule : filter_id($rule), $param);
	}

	/**
	 * 验证某个字段等于某个值的时候必须
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @param array     $data  数据
	 * @return bool
	 */
	protected function requireIf($value, $rule, $data)
	{
		list($field, $val) = explode(',', $rule);
		if ($this->getDataValue($data, $field) == $val) {
			return !empty($value);
		} else {
			return true;
		}
	}

	/**
	 * 通过回调方法验证某个字段是否必须
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @param array     $data  数据
	 * @return bool
	 */
	protected function requireCallback($value, $rule, $data)
	{
		$result = call_user_func_array($rule, [$value, $data]);
		if ($result) {
			return !empty($value);
		} else {
			return true;
		}
	}

	/**
	 * 验证某个字段有值的情况下必须
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @param array     $data  数据
	 * @return bool
	 */
	protected function requireWith($value, $rule, $data)
	{
		$val = $this->getDataValue($data, $rule);
		if (!empty($val)) {
			return !empty($value);
		} else {
			return true;
		}
	}

	/**
	 * 验证是否在范围内
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function in($value, $rule)
	{
		return in_array($value, is_array($rule) ? $rule : explode(',', $rule));
	}

	/**
	 * 验证是否不在某个范围
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function notIn($value, $rule)
	{
		return !in_array($value, is_array($rule) ? $rule : explode(',', $rule));
	}

	/**
	 * between验证数据
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function between($value, $rule)
	{
		if (is_string($rule)) {
			$rule = explode(',', $rule);
		}
		list($min, $max) = $rule;
		return $value >= $min && $value <= $max;
	}

	/**
	 * 使用notbetween验证数据
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function notBetween($value, $rule)
	{
		if (is_string($rule)) {
			$rule = explode(',', $rule);
		}
		list($min, $max) = $rule;
		return $value < $min || $value > $max;
	}

	/**
	 * 验证数据长度
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function length($value, $rule)
	{
		if (is_array($value)) {
			$length = count($value);
		} elseif ($value instanceof \think\File) {
			$length = $value->getSize();
		} else {
			$length = mb_strlen((string) $value);
		}

		if (strpos($rule, ',')) {
			// 长度区间
			list($min, $max) = explode(',', $rule);
			return $length >= $min && $length <= $max;
		} else {
			// 指定长度
			return $length == $rule;
		}
	}

	/**
	 * 验证数据最大长度
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function max($value, $rule)
	{
		if (is_array($value)) {
			$length = count($value);
		} elseif ($value instanceof \think\File) {
			$length = $value->getSize();
		} else {
			$length = mb_strlen((string) $value);
		}
		return $length <= $rule;
	}

	/**
	 * 验证数据最小长度
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function min($value, $rule)
	{
		if (is_array($value)) {
			$length = count($value);
		} elseif ($value instanceof \think\File) {
			$length = $value->getSize();
		} else {
			$length = mb_strlen((string) $value);
		}
		return $length >= $rule;
	}

	/**
	 * 验证日期
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function after($value, $rule)
	{
		return strtotime($value) >= strtotime($rule);
	}

	/**
	 * 验证日期
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function before($value, $rule)
	{
		return strtotime($value) <= strtotime($rule);
	}

	/**
	 * 验证有效期
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return bool
	 */
	protected function expire($value, $rule)
	{
		if (is_string($rule)) {
			$rule = explode(',', $rule);
		}
		list($start, $end) = $rule;
		if (!is_numeric($start)) {
			$start = strtotime($start);
		}

		if (!is_numeric($end)) {
			$end = strtotime($end);
		}
		return $_SERVER['REQUEST_TIME'] >= $start && $_SERVER['REQUEST_TIME'] <= $end;
	}

	/**
	 * 验证IP许可
	 * @access protected
	 * @param string    $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return mixed
	 */
	protected function allowIp($value, $rule)
	{
		return in_array($_SERVER['REMOTE_ADDR'], is_array($rule) ? $rule : explode(',', $rule));
	}

	/**
	 * 验证IP禁用
	 * @access protected
	 * @param string    $value  字段值
	 * @param mixed     $rule  验证规则
	 * @return mixed
	 */
	protected function denyIp($value, $rule)
	{
		return !in_array($_SERVER['REMOTE_ADDR'], is_array($rule) ? $rule : explode(',', $rule));
	}

	/**
	 * 使用正则验证数据
	 * @access protected
	 * @param mixed     $value  字段值
	 * @param mixed     $rule  验证规则 正则规则或者预定义正则名
	 * @return mixed
	 */
	protected function regex($value, $rule)
	{
		if (isset($this->regex[$rule])) {
			$rule = $this->regex[$rule];
		}
		if (0 !== strpos($rule, '/') && !preg_match('/\/[imsU]{0,4}$/', $rule)) {
			// 不是正则表达式则两端补上/
			$rule = '/^' . $rule . '$/';
		}
		return 1 === preg_match($rule, (string) $value);
	}

	// 获取错误信息
	public function getError()
	{
		return $this->error;
	}

	/**
	 * 获取数据值
	 * @access protected
	 * @param array     $data  数据
	 * @param string    $key  数据标识 支持二维
	 * @return mixed
	 */
	protected function getDataValue($data, $key)
	{
		if (strpos($key, '.')) {
			// 支持二维数组验证
			list($name1, $name2) = explode('.', $key);
			$value               = isset($data[$name1][$name2]) ? $data[$name1][$name2] : null;
		} else {
			$value = isset($data[$key]) ? $data[$key] : null;
		}
		return $value;
	}

	/**
	 * 获取验证规则的错误提示信息
	 * @access protected
	 * @param string    $attribute  字段英文名
	 * @param string    $title  字段描述名
	 * @param string    $type  验证规则名称
	 * @param mixed     $rule  验证规则数据
	 * @return string
	 */
	protected function getRuleMsg($attribute, $title, $type, $rule)
	{
		if (isset($this->message[$attribute . '.' . $type])) {
			$msg = $this->message[$attribute . '.' . $type];
		} elseif (isset($this->message[$attribute])) {
			$msg = $this->message[$attribute];
		} elseif (isset(self::$typeMsg[$type])) {
			$msg = self::$typeMsg[$type];
		} else {
			$msg = $title . '规则错误';
		}
		// TODO 多语言支持
		if (is_string($msg) && false !== strpos($msg, ':')) {
			// 变量替换
			if (strpos($rule, ',')) {
				$array = array_pad(explode(',', $rule), 3, '');
			} else {
				$array = array_pad([], 3, '');
			}
			$msg = str_replace(
				[':attribute', ':rule', ':1', ':2', ':3'],
				[$title, (string) $rule, $array[0], $array[1], $array[2]],
				$msg);
		}
		return $msg;
	}

	/**
	 * 获取数据验证的场景
	 * @access protected
	 * @param string $scene  验证场景
	 * @return array
	 */
	protected function getScene($scene = '')
	{
		if (empty($scene)) {
			// 读取指定场景
			$scene = $this->currentScene;
		}

		if (!empty($scene) && isset($this->scene[$scene])) {
			// 如果设置了验证适用场景
			$scene = $this->scene[$scene];
			if (is_string($scene)) {
				$scene = explode(',', $scene);
			}
		} else {
			$scene = [];
		}
		return $scene;
	}

	public static function __callStatic($method, $params)
	{
		$class = new static;
		if (method_exists($class, $method)) {
			return call_user_func_array([$class, $method], $params);
		} else {
			throw new \BadMethodCallException('method not exists:' . __CLASS__ . '->' . $method);
		}
	}
}
